Termination w.r.t. Q proof of TRS/AProVEAAECC.trs

Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

IF3₃(store, m, false) -> SNDSPLIT₂(m, app₂(map_f₂(self, nil), store))
PROCESS₂(store, m) -> LENGTH₁(store)
SNDSPLIT₂(s₁(n), cons₂(h, t)) -> SNDSPLIT₂(n, t)
IF2₃(store, m, false) -> PROCESS₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
IF3₃(store, m, false) -> PROCESS₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)
IF2₃(store, m, false) -> APP₂(map_f₂(self, nil), sndsplit₂(m, store))
IF1₃(store, m, true) -> FSTSPLIT₂(m, store)
IF2₃(store, m, false) -> MAP_F₂(self, nil)
MAP_F₂(pid, cons₂(h, t)) -> APP₂(f₂(pid, h), map_f₂(pid, t))
IF1₃(store, m, true) -> EMPTY₁(fstsplit₂(m, store))
PROCESS₂(store, m) -> IF1₃(store, m, leq₂(m, length₁(store)))
IF3₃(store, m, false) -> APP₂(map_f₂(self, nil), store)
FSTSPLIT₂(s₁(n), cons₂(h, t)) -> FSTSPLIT₂(n, t)
IF1₃(store, m, true) -> IF2₃(store, m, empty₁(fstsplit₂(m, store)))
IF1₃(store, m, false) -> MAP_F₂(self, nil)
IF1₃(store, m, false) -> FSTSPLIT₂(m, app₂(map_f₂(self, nil), store))
IF1₃(store, m, false) -> EMPTY₁(fstsplit₂(m, app₂(map_f₂(self, nil), store)))
APP₂(cons₂(h, t), x) -> APP₂(t, x)
IF3₃(store, m, false) -> MAP_F₂(self, nil)
LENGTH₁(cons₂(h, t)) -> LENGTH₁(t)
IF2₃(store, m, false) -> SNDSPLIT₂(m, store)
PROCESS₂(store, m) -> LEQ₂(m, length₁(store))
IF1₃(store, m, false) -> IF3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
LEQ₂(s₁(n), s₁(m)) -> LEQ₂(n, m)
MAP_F₂(pid, cons₂(h, t)) -> MAP_F₂(pid, t)
IF1₃(store, m, false) -> APP₂(map_f₂(self, nil), store)

The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF3₃(store, m, false) -> SNDSPLIT₂(m, app₂(map_f₂(self, nil), store))
PROCESS₂(store, m) -> LENGTH₁(store)
SNDSPLIT₂(s₁(n), cons₂(h, t)) -> SNDSPLIT₂(n, t)
IF2₃(store, m, false) -> PROCESS₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
IF3₃(store, m, false) -> PROCESS₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)
IF2₃(store, m, false) -> APP₂(map_f₂(self, nil), sndsplit₂(m, store))
IF1₃(store, m, true) -> FSTSPLIT₂(m, store)
IF2₃(store, m, false) -> MAP_F₂(self, nil)
MAP_F₂(pid, cons₂(h, t)) -> APP₂(f₂(pid, h), map_f₂(pid, t))
IF1₃(store, m, true) -> EMPTY₁(fstsplit₂(m, store))
PROCESS₂(store, m) -> IF1₃(store, m, leq₂(m, length₁(store)))
IF3₃(store, m, false) -> APP₂(map_f₂(self, nil), store)
FSTSPLIT₂(s₁(n), cons₂(h, t)) -> FSTSPLIT₂(n, t)
IF1₃(store, m, true) -> IF2₃(store, m, empty₁(fstsplit₂(m, store)))
IF1₃(store, m, false) -> MAP_F₂(self, nil)
IF1₃(store, m, false) -> FSTSPLIT₂(m, app₂(map_f₂(self, nil), store))
IF1₃(store, m, false) -> EMPTY₁(fstsplit₂(m, app₂(map_f₂(self, nil), store)))
APP₂(cons₂(h, t), x) -> APP₂(t, x)
IF3₃(store, m, false) -> MAP_F₂(self, nil)
LENGTH₁(cons₂(h, t)) -> LENGTH₁(t)
IF2₃(store, m, false) -> SNDSPLIT₂(m, store)
PROCESS₂(store, m) -> LEQ₂(m, length₁(store))
IF1₃(store, m, false) -> IF3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
LEQ₂(s₁(n), s₁(m)) -> LEQ₂(n, m)
MAP_F₂(pid, cons₂(h, t)) -> MAP_F₂(pid, t)
IF1₃(store, m, false) -> APP₂(map_f₂(self, nil), store)

The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 7 SCCs with 15 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APP₂(cons₂(h, t), x) -> APP₂(t, x)

The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

APP₂(cons₂(h, t), x) -> APP₂(t, x)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(APP₂(x₁, x₂)) = x₁
POL(cons₂(x₁, x₂)) = 1 + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

MAP_F₂(pid, cons₂(h, t)) -> MAP_F₂(pid, t)

The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

MAP_F₂(pid, cons₂(h, t)) -> MAP_F₂(pid, t)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(MAP_F₂(x₁, x₂)) = x₂
POL(cons₂(x₁, x₂)) = 1 + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LENGTH₁(cons₂(h, t)) -> LENGTH₁(t)

The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

LENGTH₁(cons₂(h, t)) -> LENGTH₁(t)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(LENGTH₁(x₁)) = x₁
POL(cons₂(x₁, x₂)) = 1 + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LEQ₂(s₁(n), s₁(m)) -> LEQ₂(n, m)

The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

LEQ₂(s₁(n), s₁(m)) -> LEQ₂(n, m)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(LEQ₂(x₁, x₂)) = x₁
POL(s₁(x₁)) = 1 + x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SNDSPLIT₂(s₁(n), cons₂(h, t)) -> SNDSPLIT₂(n, t)

The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

SNDSPLIT₂(s₁(n), cons₂(h, t)) -> SNDSPLIT₂(n, t)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(SNDSPLIT₂(x₁, x₂)) = x₁
POL(cons₂(x₁, x₂)) = 0
POL(s₁(x₁)) = 1 + x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FSTSPLIT₂(s₁(n), cons₂(h, t)) -> FSTSPLIT₂(n, t)

The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

FSTSPLIT₂(s₁(n), cons₂(h, t)) -> FSTSPLIT₂(n, t)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(FSTSPLIT₂(x₁, x₂)) = x₁
POL(cons₂(x₁, x₂)) = 0
POL(s₁(x₁)) = 1 + x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROCESS₂(store, m) -> IF1₃(store, m, leq₂(m, length₁(store)))
IF1₃(store, m, false) -> IF3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
IF3₃(store, m, false) -> PROCESS₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)
IF2₃(store, m, false) -> PROCESS₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
IF1₃(store, m, true) -> IF2₃(store, m, empty₁(fstsplit₂(m, store)))

The TRS R consists of the following rules:

fstsplit₂(0, x) -> nil
fstsplit₂(s₁(n), nil) -> nil
fstsplit₂(s₁(n), cons₂(h, t)) -> cons₂(h, fstsplit₂(n, t))
sndsplit₂(0, x) -> x
sndsplit₂(s₁(n), nil) -> nil
sndsplit₂(s₁(n), cons₂(h, t)) -> sndsplit₂(n, t)
empty₁(nil) -> true
empty₁(cons₂(h, t)) -> false
leq₂(0, m) -> true
leq₂(s₁(n), 0) -> false
leq₂(s₁(n), s₁(m)) -> leq₂(n, m)
length₁(nil) -> 0
length₁(cons₂(h, t)) -> s₁(length₁(t))
app₂(nil, x) -> x
app₂(cons₂(h, t), x) -> cons₂(h, app₂(t, x))
map_f₂(pid, nil) -> nil
map_f₂(pid, cons₂(h, t)) -> app₂(f₂(pid, h), map_f₂(pid, t))
process₂(store, m) -> if1₃(store, m, leq₂(m, length₁(store)))
if1₃(store, m, true) -> if2₃(store, m, empty₁(fstsplit₂(m, store)))
if1₃(store, m, false) -> if3₃(store, m, empty₁(fstsplit₂(m, app₂(map_f₂(self, nil), store))))
if2₃(store, m, false) -> process₂(app₂(map_f₂(self, nil), sndsplit₂(m, store)), m)
if3₃(store, m, false) -> process₂(sndsplit₂(m, app₂(map_f₂(self, nil), store)), m)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.